package com.sxf.core.db.page;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.metadata.OrderItem;
import com.fasterxml.jackson.annotation.JsonIgnore;
import io.swagger.annotations.ApiModelProperty;
import org.apache.commons.collections.CollectionUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

/**
 * 分页模型数据，能够记录每行记录数，当前页数等，以及查询返回的结果信息。
 *
 * @author zhiwei.han
 * @date 2019年8月12日
 */
public class Pagination<T> implements IPage<T> {
    private static final long serialVersionUID = -6393108247117942719L;

    /** 当前页 */
    @ApiModelProperty("当前页")
    private int page;

    /** 每页显示行数 */
    @ApiModelProperty("每页显示行数")
    private int pageSize;

    /** 排序对象 */
    @ApiModelProperty("排序对象")
    private Sort sort;

    /** 总记录数，用于查询结果返回 */
    @ApiModelProperty("总记录数")
    private long total;

    /** 总记录页数 */
    @ApiModelProperty("总记录页数")
    private int totalPage;

    /** 查询结果数据，用于查询结果返回 */
    @ApiModelProperty("查询结果数据")
    private List<T> dataset;

    /**
     * 创建新的分页数据model {@link Pagination}。<br>
     * 页数从0开始计数，因此如果指定为0，则返回第一页数据。
     *
     * @param page 当前页号
     * @param pageSize 每页记录数
     */
    public Pagination(int page, int pageSize) {
        this(page, pageSize, null);
    }

    public Pagination() {}

    /**
     * 依据给定的排序信息创建分页数据model {@link Pagination}.
     *
     * @param page 当前页号
     * @param pageSize 每页行数
     * @param direction 排序方向，{@link }}
     * @param properties 排序的字段
     */
    public Pagination(int page, int pageSize, Direction direction, String... properties) {
        this(page, pageSize, new Sort(direction, properties));
    }

    /**
     * 依据给定的排序信息创建分页数据model {@link Pagination}..
     *
     * @param page 当前页号
     * @param pageSize 每页行数
     * @param sort 排序信息
     */
    public Pagination(int page, int pageSize, Sort sort) {
        if (0 > page) {
            throw new IllegalArgumentException("Page index must not be less than zero!");
        }

        if (0 >= pageSize) {
            throw new IllegalArgumentException("Page pageSize must not be less than or equal to zero!");
        }

        this.page = page;
        this.pageSize = pageSize;
        this.sort = sort;
    }
    
    /**
     * 依据给定的排序信息创建分页数据model {@link Pagination}..
     * @param pageParam
     */
    public Pagination(PageParam pageParam) {
        this(pageParam.getPage(), pageParam.getPageSize(), pageParam.getSort());
    }

    /**
     * 设置查询结果信息
     *
     * @param dataset
     * @param total
     */
    public void setResultInfo(List<T> dataset, long total) {
        this.dataset = dataset;
        this.total = total;
    }

    /**
     * 获取记录偏移量
     *
     * @return 记录偏移量
     */
    @ApiModelProperty("记录偏移量")
    public int getOffset() {
        return (page - 1) * pageSize;
    }

    /** @return the total */
    @Override
    public long getTotal() {
        return total;
    }

    /** @return the dataset */
    public List<T> getDataset() {
        return dataset;
    }

    /** @param dataset the dataset to set */
    public void setDataset(List<T> dataset) {
        this.dataset = dataset;
    }

    /** @return the page */
    public int getPage() {
        return page;
    }

    /** @return the pageSize */
    public int getPageSize() {
        return pageSize;
    }

    /** @return the sort */
    public Sort getSort() {
        return sort;
    }

    public int getTotalPage() {
        this.totalPage = (int)IPage.super.getPages();
        return totalPage;
    }

    public void setTotalPage(int totalPage) {
        this.totalPage = totalPage;
    }

    /**
     * --------------------新实现--------------------
     */

    @Override
    @JsonIgnore
    public List<OrderItem> orders() {
        List<OrderItem> orderArray = new ArrayList<>();
        if (Objects.isNull(sort) || CollectionUtils.isEmpty(sort.getOrders())) {
            return orderArray;
        }
        sort.getOrders().forEach(orderSort -> {
            OrderItem orderItem = new OrderItem();
            orderItem.setColumn(orderSort.getProperty());
            orderItem.setAsc(orderSort.getDirection() == Direction.ASC);
            orderArray.add(orderItem);
        });
        return orderArray;
    }

    @Override
    @JsonIgnore
    public List<T> getRecords() {
        return dataset;
    }

    @Override
    @JsonIgnore
    public IPage<T> setRecords(List<T> records) {
        this.dataset = records;
        return this;
    }

    @Override
    public IPage<T> setTotal(long total) {
        this.total = total;
        return this;
    }

    @Override
    @JsonIgnore
    public long getSize() {
        return pageSize;
    }

    @Override
    @JsonIgnore
    public IPage<T> setSize(long size) {
        this.pageSize = (int)size;
        return this;
    }

    @Override
    @JsonIgnore
    public long getCurrent() {
        return page;
    }

    @Override
    @JsonIgnore
    public IPage<T> setCurrent(long current) {
        this.page = (int)current;
        return this;
    }

    public void setPage(int page) {
        this.page = page;
    }

    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }

    public void setSort(Sort sort) {
        this.sort = sort;
    }

    @Override
    @JsonIgnore
    public boolean isSearchCount() {
        return IPage.super.isSearchCount();
    }

    @Override
    @JsonIgnore
    public long getPages() {
        return IPage.super.getPages();
    }

    @Override
    @JsonIgnore
    public boolean isHitCount() {
        return IPage.super.isHitCount();
    }
    
    

}
